// 本地AI工具 - 基于规则引擎的智能分析
class LocalAI {
  constructor() {
    this.isLoaded = false
    this.colorRules = null
    this.styleRules = null
  }

  // 初始化本地AI规则引擎
  async initialize() {
    try {
      console.log('初始化本地AI规则引擎...')

      // 初始化颜色搭配规则
      this.initColorRules()

      // 初始化风格分析规则
      this.initStyleRules()

      this.isLoaded = true
      console.log('本地AI规则引擎初始化完成')

      return true
    } catch (error) {
      console.error('本地AI初始化失败:', error)
      return false
    }
  }

  // 初始化颜色搭配规则
  initColorRules() {
    this.colorRules = {
      // 基础色搭配规则
      complementary: {
        '#FF0000': ['#00FF00', '#FFFFFF', '#000000'], // 红色
        '#00FF00': ['#FF0000', '#FFFFFF', '#000000'], // 绿色
        '#0000FF': ['#FFA500', '#FFFFFF', '#000000'], // 蓝色
        '#FFFF00': ['#800080', '#FFFFFF', '#000000'], // 黄色
        '#800080': ['#FFFF00', '#FFFFFF', '#000000'], // 紫色
        '#FFA500': ['#0000FF', '#FFFFFF', '#000000']  // 橙色
      },

      // 类似色搭配
      analogous: {
        '#FF0000': ['#FF4500', '#FF69B4', '#DC143C'], // 红色系
        '#0000FF': ['#4169E1', '#1E90FF', '#87CEEB'], // 蓝色系
        '#00FF00': ['#32CD32', '#90EE90', '#98FB98'], // 绿色系
        '#FFFF00': ['#FFD700', '#FFA500', '#FF8C00']  // 黄色系
      },

      // 经典搭配
      classic: {
        black: ['#FFFFFF', '#808080', '#C0C0C0'],
        white: ['#000000', '#808080', '#Navy'],
        navy: ['#FFFFFF', '#Beige', '#Gold'],
        beige: ['#Navy', '#Brown', '#White']
      }
    }

    console.log('颜色搭配规则初始化完成')
  }

  // 初始化风格分析规则
  initStyleRules() {
    this.styleRules = {
      // 风格特征关键词
      casual: ['休闲', 'T恤', '牛仔裤', '运动鞋', '卫衣'],
      formal: ['正式', '西装', '衬衫', '皮鞋', '领带'],
      sport: ['运动', '运动服', '运动鞋', '健身', '瑜伽'],
      sweet: ['甜美', '连衣裙', '粉色', '蝴蝶结', '花朵'],
      cool: ['酷帅', '皮衣', '黑色', '马丁靴', '朋克']
    }

    console.log('风格分析规则初始化完成')
  }

  // 颜色搭配分析
  async analyzeColorMatching(primaryColor) {
    if (!this.isLoaded) {
      return this.fallbackColorAnalysis(primaryColor)
    }

    try {
      // 基于规则的颜色搭配分析
      const suggestedColors = []

      // 查找互补色
      const complementaryColors = this.colorRules.complementary[primaryColor.toUpperCase()]
      if (complementaryColors) {
        suggestedColors.push(...complementaryColors)
      }

      // 查找类似色
      const analogousColors = this.colorRules.analogous[primaryColor.toUpperCase()]
      if (analogousColors) {
        suggestedColors.push(...analogousColors.slice(0, 2))
      }

      // 如果没有找到预定义规则，使用算法生成
      if (suggestedColors.length === 0) {
        suggestedColors.push(
          this.getComplementaryColor(primaryColor),
          this.getAnalogousColor(primaryColor),
          '#FFFFFF', // 白色百搭
          '#000000'  // 黑色百搭
        )
      }

      return {
        primaryColor,
        suggestedColors: [...new Set(suggestedColors)], // 去重
        analysis: this.generateColorAnalysis(primaryColor),
        confidence: 0.85
      }
    } catch (error) {
      console.error('颜色分析失败:', error)
      return this.fallbackColorAnalysis(primaryColor)
    }
  }

  // 风格分析
  async analyzeStyle(clothingFeatures) {
    if (!this.isLoaded) {
      return this.fallbackStyleAnalysis(clothingFeatures)
    }

    try {
      // 基于规则的风格分析
      const styleScores = {
        '休闲': 0,
        '正式': 0,
        '运动': 0,
        '甜美': 0,
        '酷帅': 0
      }

      // 分析特征关键词
      const description = `${clothingFeatures.category || ''} ${clothingFeatures.style || ''} ${clothingFeatures.name || ''}`.toLowerCase()

      // 计算各风格得分
      Object.keys(this.styleRules).forEach(style => {
        const keywords = this.styleRules[style]
        keywords.forEach(keyword => {
          if (description.includes(keyword.toLowerCase())) {
            const styleLabel = this.getStyleLabel(style)
            styleScores[styleLabel] += 0.2
          }
        })
      })

      // 根据颜色调整得分
      if (clothingFeatures.color) {
        this.adjustScoresByColor(styleScores, clothingFeatures.color)
      }

      // 找出主要风格
      const maxStyle = Object.keys(styleScores).reduce((a, b) =>
        styleScores[a] > styleScores[b] ? a : b
      )

      return {
        primaryStyle: maxStyle,
        confidence: Math.min(styleScores[maxStyle] + 0.5, 1.0),
        styleScores: Object.keys(styleScores).map(style => ({
          style,
          score: styleScores[style]
        })),
        recommendations: this.generateStyleRecommendations(maxStyle)
      }
    } catch (error) {
      console.error('风格分析失败:', error)
      return this.fallbackStyleAnalysis(clothingFeatures)
    }
  }

  // 智能搭配推荐
  async generateOutfitRecommendation(userPreferences, weatherInfo, availableClothing) {
    const analysis = {
      weather: weatherInfo,
      recommendations: [],
      reasoning: []
    }

    // 基于天气的基础推荐
    const weatherRec = this.getWeatherBasedRecommendation(weatherInfo)
    analysis.recommendations.push(weatherRec)
    analysis.reasoning.push(`根据${weatherInfo.condition} ${weatherInfo.temperature}°C的天气`)

    // 基于用户偏好的推荐
    if (userPreferences.preferredStyle) {
      const styleRec = this.getStyleBasedRecommendation(userPreferences.preferredStyle)
      analysis.recommendations.push(styleRec)
      analysis.reasoning.push(`符合您的${userPreferences.preferredStyle}风格偏好`)
    }

    // 颜色搭配推荐
    if (userPreferences.favoriteColors && userPreferences.favoriteColors.length > 0) {
      const colorRec = await this.analyzeColorMatching(userPreferences.favoriteColors[0])
      analysis.recommendations.push({
        type: 'color',
        colors: colorRec.suggestedColors,
        description: '基于您喜欢的颜色推荐的搭配色彩'
      })
      analysis.reasoning.push('基于您的颜色偏好')
    }

    return analysis
  }

  // 辅助方法
  hexToRgb(hex) {
    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
    return result ? {
      r: parseInt(result[1], 16),
      g: parseInt(result[2], 16),
      b: parseInt(result[3], 16)
    } : null
  }

  rgbToHex(r, g, b) {
    return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)
  }

  getComplementaryColor(hex) {
    const rgb = this.hexToRgb(hex)
    if (!rgb) return '#000000'

    return this.rgbToHex(255 - rgb.r, 255 - rgb.g, 255 - rgb.b)
  }

  getAnalogousColor(hex) {
    const rgb = this.hexToRgb(hex)
    if (!rgb) return '#000000'

    // 简单的类似色计算
    const newR = Math.min(255, rgb.r + 30)
    const newG = Math.max(0, rgb.g - 30)
    const newB = rgb.b

    return this.rgbToHex(newR, newG, newB)
  }

  extractStyleFeatures(clothingFeatures) {
    // 将衣服特征转换为数值向量
    const features = new Array(10).fill(0)

    // 这里可以根据实际的衣服属性来提取特征
    if (clothingFeatures.category) {
      features[0] = this.getCategoryScore(clothingFeatures.category)
    }

    if (clothingFeatures.color) {
      const rgb = this.hexToRgb(clothingFeatures.color)
      if (rgb) {
        features[1] = rgb.r / 255
        features[2] = rgb.g / 255
        features[3] = rgb.b / 255
      }
    }

    if (clothingFeatures.style) {
      features[4] = this.getStyleScore(clothingFeatures.style)
    }

    return features
  }

  getCategoryScore(category) {
    const categoryMap = {
      '上装': 0.1,
      '下装': 0.2,
      '外套': 0.3,
      '鞋子': 0.4,
      '配饰': 0.5
    }
    return categoryMap[category] || 0
  }

  getStyleScore(style) {
    const styleMap = {
      '休闲': 0.1,
      '正式': 0.2,
      '运动': 0.3,
      '甜美': 0.4,
      '酷帅': 0.5
    }
    return styleMap[style] || 0
  }

  // 降级方案
  fallbackColorAnalysis(color) {
    return {
      primaryColor: color,
      suggestedColors: ['#FFFFFF', '#000000', '#808080'],
      analysis: '基于经典配色原理的搭配建议',
      confidence: 0.7
    }
  }

  fallbackStyleAnalysis(features) {
    return {
      primaryStyle: '休闲',
      confidence: 0.7,
      styleScores: [
        { style: '休闲', score: 0.7 },
        { style: '正式', score: 0.1 },
        { style: '运动', score: 0.1 },
        { style: '甜美', score: 0.05 },
        { style: '酷帅', score: 0.05 }
      ],
      recommendations: ['建议选择舒适的休闲装']
    }
  }

  generateColorAnalysis(primary) {
    return `${primary} 与建议的搭配色彩形成和谐的色彩组合，适合日常穿搭`
  }

  // 获取风格标签
  getStyleLabel(styleKey) {
    const labelMap = {
      casual: '休闲',
      formal: '正式',
      sport: '运动',
      sweet: '甜美',
      cool: '酷帅'
    }
    return labelMap[styleKey] || '休闲'
  }

  // 根据颜色调整风格得分
  adjustScoresByColor(styleScores, color) {
    const colorLower = color.toLowerCase()

    // 黑色增加酷帅和正式得分
    if (colorLower.includes('黑') || colorLower.includes('black')) {
      styleScores['酷帅'] += 0.3
      styleScores['正式'] += 0.2
    }

    // 粉色增加甜美得分
    if (colorLower.includes('粉') || colorLower.includes('pink')) {
      styleScores['甜美'] += 0.4
    }

    // 蓝色增加休闲得分
    if (colorLower.includes('蓝') || colorLower.includes('blue')) {
      styleScores['休闲'] += 0.2
    }

    // 白色增加正式得分
    if (colorLower.includes('白') || colorLower.includes('white')) {
      styleScores['正式'] += 0.2
    }
  }

  generateStyleRecommendations(style) {
    const recommendations = {
      '休闲': ['T恤+牛仔裤', '卫衣+运动裤', '衬衫+休闲裤'],
      '正式': ['西装+衬衫', '连衣裙+外套', '正装+皮鞋'],
      '运动': ['运动上衣+运动裤', '运动鞋+运动袜', '运动外套'],
      '甜美': ['连衣裙+小外套', '粉色系搭配', '蝴蝶结配饰'],
      '酷帅': ['皮衣+牛仔裤', '黑色系搭配', '马丁靴']
    }

    return recommendations[style] || ['基础搭配建议']
  }

  getWeatherBasedRecommendation(weather) {
    const temp = weather.temperature

    if (temp < 5) {
      return {
        type: 'weather',
        items: ['厚外套', '毛衣', '长裤', '靴子'],
        description: '寒冷天气保暖搭配'
      }
    } else if (temp < 15) {
      return {
        type: 'weather',
        items: ['外套', '长袖', '长裤', '运动鞋'],
        description: '凉爽天气舒适搭配'
      }
    } else if (temp < 25) {
      return {
        type: 'weather',
        items: ['薄外套', '长袖/短袖', '长裤'],
        description: '温和天气轻松搭配'
      }
    } else {
      return {
        type: 'weather',
        items: ['短袖', '短裤/裙子', '凉鞋'],
        description: '炎热天气清爽搭配'
      }
    }
  }

  getStyleBasedRecommendation(style) {
    const recommendations = {
      '休闲': {
        type: 'style',
        items: ['T恤', '牛仔裤', '运动鞋'],
        description: '休闲舒适的日常搭配'
      },
      '正式': {
        type: 'style',
        items: ['衬衫', '西装裤', '皮鞋'],
        description: '正式得体的商务搭配'
      },
      '运动': {
        type: 'style',
        items: ['运动上衣', '运动裤', '运动鞋'],
        description: '活力十足的运动搭配'
      }
    }

    return recommendations[style] || recommendations['休闲']
  }
}

// 创建全局实例
const localAI = new LocalAI()

export default localAI
